package org.dtrd.modules.flup.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.dtrd.config.system.Constant;
import org.dtrd.modules.flup.entity.bean.FlupTemplateProjectDetail;
import org.dtrd.modules.flup.entity.bean.FlupTemplateProjectListInfo;
import org.dtrd.modules.flup.entity.po.DtrdEntRdFlupTemplateProject;
import org.dtrd.modules.flup.entity.po.DtrdRlFlupProjectRecord;
import org.dtrd.modules.flup.entity.request.FlupTemplateProjectListRequest;
import org.dtrd.modules.flup.mapper.DtrdEntRdFlupTemplateProjectMapper;
import org.dtrd.modules.flup.service.IDtrdEntRdFlupTemplateProjectService;
import org.dtrd.modules.flup.service.IDtrdRlFlupProjectRecordService;
import org.dtrd.modules.flup.service.IDtrdRlFlupTemplateProjectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;


/**
 * <p>
 * 复诊模版项目 服务实现类
 * </p>
 *
 * @author QR
 * @since 2021-12-21
 */
@DS("multi-datasource1")
@Service
public class DtrdEntRdFlupTemplateProjectServiceImpl extends ServiceImpl<DtrdEntRdFlupTemplateProjectMapper, DtrdEntRdFlupTemplateProject> implements IDtrdEntRdFlupTemplateProjectService {

    @Autowired
    private IDtrdRlFlupTemplateProjectService flupTemplateProjectRlService;
    @Autowired
    private IDtrdRlFlupProjectRecordService flupProjectRecordService;

    @Override
    public List<FlupTemplateProjectListInfo> getFlupTemplateProjectList(FlupTemplateProjectListRequest request) {
        LambdaQueryWrapper<DtrdEntRdFlupTemplateProject> queryWrapper = baseQueryWrapper()
                .eq(StringUtils.isNotBlank(request.getOrgCode()),
                        DtrdEntRdFlupTemplateProject::getOrgCode,request.getOrgCode())
                .orderByAsc(DtrdEntRdFlupTemplateProject::getOrderNum)
                .orderByDesc(DtrdEntRdFlupTemplateProject::getUpdateTime);
        Integer templateId = request.getTemplateId();
        List<DtrdEntRdFlupTemplateProject> poList = list(queryWrapper);
        List<FlupTemplateProjectListInfo> dtoList = new ArrayList<>(poList.size());
        if (!poList.isEmpty()) {
            dtoList = poList.stream().map(FlupTemplateProjectListInfo::new).collect(Collectors.toList());
        }
        // 设置与当前模版的标记
        if (templateId != null) {
            List<Integer> projectIds = flupTemplateProjectRlService.getProjectIds(templateId);
            if (CollectionUtil.isNotEmpty(projectIds)) {
                dtoList.forEach(dto -> {
                    if (projectIds.contains(dto.getDataId())) {
                        dto.setFlag(true);
                    }
                });
            }
        }
        return dtoList;
    }

    public FlupTemplateProjectDetail getFlupTemplateProject(Integer dataId) {
        DtrdEntRdFlupTemplateProject dtrdEntRdFlupTemplateProject = getById(dataId);
        return Optional.ofNullable(dtrdEntRdFlupTemplateProject)
                        .map(po -> new FlupTemplateProjectDetail().parseFromPo(po))
                        .orElse(null);
    }

    @Override
    public boolean saveOrUpdateFlupTemplateProject(FlupTemplateProjectDetail dto) {
        DtrdEntRdFlupTemplateProject dtrdEntRdFlupTemplateProject = new DtrdEntRdFlupTemplateProject();
        if(dto.getDataId() == null){
            dtrdEntRdFlupTemplateProject = dtrdEntRdFlupTemplateProject.init();
        }else {
            LambdaQueryWrapper<DtrdRlFlupProjectRecord> wrapper = Wrappers.lambdaQuery(DtrdRlFlupProjectRecord.class)
                    .eq(DtrdRlFlupProjectRecord::getProjectId, dto.getDataId());
            List<DtrdRlFlupProjectRecord> records = flupProjectRecordService.list(wrapper);
            if (CollectionUtil.isNotEmpty(records)) {
                for (DtrdRlFlupProjectRecord record : records) {
                    record.setProjectName(dto.getTemplateProjectName());
                }
                flupProjectRecordService.updateBatchById(records);
            }
        }
        dtrdEntRdFlupTemplateProject.parseFromDto(dto);
        return saveOrUpdate(dtrdEntRdFlupTemplateProject);
    }

    @Override
    public boolean removeFlupTemplateProject(Integer dataId) {
        // 删除复诊模版项目中的记录
        return removeById(dataId);
    }

    @Override
    public Map<Integer, String> getTemplateProjectIdToDetail(Integer templateId) {
        List<DtrdEntRdFlupTemplateProject> projects = baseMapper.selectProjectsByTemplateId(templateId);
        if (CollectionUtil.isEmpty(projects)) {
            return null;
        }
        Map<Integer, String> map = new HashMap<>();
        projects.forEach(p -> {
            map.put(p.getDataId(), p.getTemplateProjectDesc());
        });
        return map;
    }

    @Override
    public boolean isInValidTemplateProjectName(String projectName, Integer dataId, String orgCode) {
        LambdaQueryWrapper<DtrdEntRdFlupTemplateProject> queryWrapper = Wrappers.lambdaQuery(DtrdEntRdFlupTemplateProject.class)
                .eq(DtrdEntRdFlupTemplateProject::getTemplateProjectName, projectName)
                .eq(DtrdEntRdFlupTemplateProject::getOrgCode, orgCode);
        DtrdEntRdFlupTemplateProject project = this.getOne(queryWrapper);
        return project != null && !Objects.equals(project.getDataId(), dataId);
    }

    @Override
    public boolean isFixedFlupTemplateProject(Integer projectId) {
        DtrdEntRdFlupTemplateProject queryProject = getById(projectId);
        if (queryProject == null) {
            return false;
        }
        return queryProject.getIsFixed().equals(Constant.FIXED);
    }

    @Override
    public String getProjectName(Integer id) {
        DtrdEntRdFlupTemplateProject queryOne = getById(id);
        return Optional.ofNullable(queryOne)
                .map(DtrdEntRdFlupTemplateProject::getTemplateProjectName)
                .orElse(null);
    }

    private LambdaQueryWrapper<DtrdEntRdFlupTemplateProject> baseQueryWrapper() {
        return Wrappers.lambdaQuery(DtrdEntRdFlupTemplateProject.class)
                        .eq(DtrdEntRdFlupTemplateProject::getIsDel, 0);
    }

    private LambdaUpdateWrapper<DtrdEntRdFlupTemplateProject> baseUpdateWrapper() {
        return Wrappers.lambdaUpdate(DtrdEntRdFlupTemplateProject.class)
                        .eq(DtrdEntRdFlupTemplateProject::getIsDel, 0);
    }
}
